#ifndef __W_SERVER_H_
#define __W_SERVER_H_

#include "db.hpp"
#include "matcher.hpp"
#include "room.hpp"
#include "online.hpp"
#include "session.hpp"
#include "util.hpp"

using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;
#define WWWROOT "./wwwroot/"

class gobang_server
{
public:
    gobang_server(const string& host, const string& username, const string& password,
                const string& dbname, uint16_t port = 3306, const string& wwwroot = WWWROOT)
            :_web_root(wwwroot), _ut(host, username, password, dbname, port), _rm(&_ut, &_om),
            _sm(&_wssvr), _mm( &_ut, &_om, &_rm)
    {
        // 2. 设置日志等级
        _wssvr.set_access_channels(websocketpp::log::alevel::none);
        // 3. 初始化asio调度器
        _wssvr.init_asio(); 
        _wssvr.set_reuse_addr(true);
        // 4. 设置回调函数
        _wssvr.set_http_handler(bind(&gobang_server::http_callback, this, _1));
        _wssvr.set_open_handler(bind(&gobang_server::wsopen_callback, this, _1));
        _wssvr.set_close_handler(bind(&gobang_server::wsclose_callback, this, _1));
        _wssvr.set_message_handler(bind(&gobang_server::wsmessage_callback, this, _1, _2));
    }
    // 启动服务器
    void start(int port)
    {
        // 5. 设置监听端口
        _wssvr.listen(port);
        // 6. 开始获取新链接
        _wssvr.start_accept();
        // 7. 启动服务器
        _wssvr.run();
    }
private:
    // 静态资源请求功能的处理
    void file_handler(wsserver_t::connection_ptr& conn)
    {   
        // 1. 获取到请求uri的资源路径, 了解客户端请求的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();

        // 2. 组合出文件的实际路径  相对根目录+uri
        string uri = req.get_uri();
        string realpath = _web_root + uri;

        // 3. 如果请求的是个目录,增加一个后缀 login.html    
        if(realpath.back() == '/')
        {
            realpath += "login.html";
        }
        
        // 4. 读取文件内容
        Json::Value resp_json;
        string body;
        bool ret = file_util::read(realpath, body);
        
        // 4.1 文件不存在 ，读取文件内容失败，返回404
        if(ret == false)
        {
            body += "<html><head><meta charset='UTF-8'/></head><body><h1>Not Nound 内容不存在</h1></body></html>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        // 5. 设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);

    }
    // 发送http响应字符串
    void http_resp(wsserver_t::connection_ptr& conn, bool result, 
        websocketpp::http::status_code::value code, const string& reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        string resp_body;
        json_util::serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->append_header("Content-Type", "application/json");
        conn->set_body(resp_body);

    }
    // 用户注册请求功能的处理
    void reg(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取正文
        websocketpp::http::parser::request req = conn->get_request();
        string req_body = conn->get_request_body();
        // 2. 对正文进行反序列化，得到用户名密码
        Json::Value login_info;

        if(json_util::unserialize(req_body, login_info) == false)
        {
            DLOG("正文反序列化失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }

        // 3.进行数据库新增用户操作
        if(login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名/密码不完整！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        if(_ut.insert(login_info) == false)
        {
            DLOG("插入用户信息失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名被注册");
        }
        // 成功返回200
        return http_resp(conn, true, websocketpp::http::status_code::ok, "注册成功");

    }
    // 用户登录请求功能的处理
    void login(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取请求正文，对正文进行反序列化，获取到用户名密码
        websocketpp::http::parser::request req = conn->get_request();
        string req_body = conn->get_request_body();
        Json::Value login_info;

        if(json_util::unserialize(req_body, login_info) == false)
        {
            DLOG("正文反序列化失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }

        // 2. 校验正文完整性，进行数据库的用户信息验证
        if(login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名/密码不完整！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        // 2.1 验证失败，返回400
        if(_ut.login(login_info) == false) 
        {
            DLOG("用户名/密码错误！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名/密码错误！");
        }
        
        // 3. 验证成功给客户端创建session
        uint64_t uid = login_info["id"].asUInt64(); 
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if(ssp.get() == nullptr)
        {
            DLOG("创建会话失败！");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败！");
        }
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIME);

        // 4. 设置响应头部：Set:Cookie 将sessionid通过cookie返回
        string cookie_ssid = "SSID=" + to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(conn, true, websocketpp::http::status_code::ok, "登陆成功");
        
    }
    // 获取cookie信息
    bool get_cookie_val(const string& cookie_str, const string& key, string& val)
    {
        // Cookie: SSID=xxx; path=/; 
        // 1. 以; 作为分隔符，对字符串进行分割，得到各个单个的Cookie信息
        string sep = "; ";
        vector<string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);

        // 2. 对单个Cookie字符串，以=作为分隔符，得到key和val
        for(auto str: cookie_arr)
        {
            vector<string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if(tmp_arr.size() != 2) { continue; }
            if(tmp_arr[0] == key)
            {
                val = tmp_arr[1];
                return true;
            }
        }
        return false;
    }
    // 用户信息获取请求功能的处理
    void info(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取请求信息中的cookie，从cookie中获取ssid
        string cookie_str = conn->get_request_header("Cookie");
        // 1.1 如果没有Cookie，返回错误：没有Cookie信息，请重新登录
        if(cookie_str.empty())
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "没有Cookie信息，请重新登录！");
        }
        // 1.2 从cookie中取出ssid
        string ssid_str; 
        if(get_cookie_val(cookie_str, "SSID", ssid_str) == false)
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录！");
        }
        // 2. 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(stol(ssid_str));
        // 2.1 没有找到session信息，则认为登录过期，需要重新登录
        if(ssp.get() == nullptr)
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "登录过期，请重新登录！");
        }

        uint64_t uid = ssp->get_user();
        // 3. 从数据库中取出用户信息，进行序列化而后发送给客户端
        Json::Value user_info;
        // 3.1 获取用户信息失败，返回错误信息
        if(_ut.select_by_id(uid, user_info) == false)
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录！");
        }

        string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->append_header("Content-Type","application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 4. 刷新session的过期时间
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIME);

    }
    // http回调函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        string method = req.get_method();
        string uri = req.get_uri();
        if(method == "POST" && uri == "/reg")
            { return reg(conn); }   //注册
        else if(method == "POST" && uri == "/login")
            { return login(conn); } //登录
        else if(method == "GET" && uri == "/info")
            { return info(conn); }  //信息获取
        else
            { return file_handler(conn); }

    }
    // -----------------------------------------------------------------------
    // 发送websocket响应
    void ws_resp(wsserver_t::connection_ptr& conn, const string& optype, 
        bool result, const string& reason)
    {
        Json::Value err_resp;
        err_resp["optype"] = optype;
        err_resp["result"] = result;
        err_resp["reason"] = reason;
        string body;
        json_util::serialize(err_resp, body);
        conn->send(body);
    }
    // 通过cookie获取session信息
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr& conn)
    {
        // 1. 登录验证，判断当前客户端是否已经登陆
        Json::Value err_resp;
        // 1. 获取请求信息中的cookie，从cookie中获取ssid
        string cookie_str = conn->get_request_header("Cookie");
        // 1.1 如果没有Cookie，返回错误：找不到Cookie信息，请重新登录
        if(cookie_str.empty())
        {
            ws_resp(conn, "hall_ready", false, "找不到Cookie信息，请重新登录");
            return session_ptr();
        }
        // 1.2 从cookie中取出ssid
        string ssid_str; 
        if(get_cookie_val(cookie_str, "SSID", ssid_str) == false)
        {
            ws_resp(conn, "hall_ready", false, "找不到ssid信息，请重新登录！");
            return session_ptr();
        }
        // 2. 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(stol(ssid_str));
        // 2.1 没有找到session信息，则认为登录过期，需要重新登录
        if(ssp.get() == nullptr)
        {
            ws_resp(conn, "hall_ready", false, "登录过期，请重新登录！");
            return session_ptr();
        }
        return ssp;
    }
    // 建立游戏大厅的长链接请求
    void wsopen_game_hall(wsserver_t::connection_ptr& conn)
    {
        // 1. 登录验证，判断当前客户端是否已经登陆
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        { return ; }
        // 2. 判断当前客户端是否重复登陆- 不支持被挤下线的功能
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            return ws_resp(conn, "hall_ready", false, "玩家重复登录！");
        }
        // 3. 将当前客户端以及链接加入大厅
        _om.enter_game_hall(ssp->get_user(), conn);

        // 4. 给客户端响应游戏大厅连接建立成功
        ws_resp(conn, "hall_ready", true, "大厅连接成功！");
        // 5. 将session设置为永久存在
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
    }
    // 建立游戏房间的长链接请求
    void wsopen_game_room(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取当前客户端的session
        // 1.1 登录验证，判断当前客户端是否已经登陆
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        { return ; }
        // 2. 判断当前用户是否已经在游戏房间/游戏大厅---在线用户管理
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            return ws_resp(conn, "room_ready", false, "玩家重复登录！");
        }
        // 3. 判断当前用户是否已经创建好房间---房间管理
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if(rp.get() == nullptr)
        { 
            return ws_resp(conn, "room_ready", false, "找不到玩家的游戏房间！");
        }
        // 4. 将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        // 5. 将session重新设置为永久
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
        // 6. 给客户端响应游戏房间连接建立成功

        Json::Value err_resp;
        err_resp["optype"] = "room_ready";
        err_resp["result"] = true;
        err_resp["reason"] = "房间建立成功";
        err_resp["room_id"] = (Json::UInt64)rp->get_room_id();
        err_resp["uid"] = (Json::UInt64)ssp->get_user();
        err_resp["white_id"] = (Json::UInt64)rp->get_white_id();
        err_resp["black_id"] = (Json::UInt64)rp->get_black_id();
        string body;
        json_util::serialize(err_resp, body);
        conn->send(body);
    }
    // websocket长链接建立成功之后的处理函数
    void wsopen_callback( websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 建立游戏大厅的长链接请求
        if(uri == "/hall")
        {
            return wsopen_game_hall(conn);
        }
        // 建立游戏房间的长链接请求
        else if( uri == "/room")
        {
            return wsopen_game_room(conn);
        }
    }
    //------------------------------------------------------------------------------
    // 关闭游戏大厅的长链接请求
    void wsclose_game_hall(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取客户端session，识别客户端信息
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
            { return ; }

        //  将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user());
        //  将session设置为定时销毁
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIME);

    }
    // 关闭游戏房间的长链接请求
    void wsclose_game_room(wsserver_t::connection_ptr& conn)
    {
        // 1. 获取客户端session，识别客户端信息
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
            { return ; }
        // 2. 将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        //  将session设置为定时销毁
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIME);
        // 将玩家从游戏房间移除，所有用户退出房间后，房间会自动销毁
        _rm.remove_room_user(ssp->get_user());
        
    }
    // 关闭websocket长链接的处理函数
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 关闭游戏大厅的长链接请求
        if(uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }
        // 关闭游戏房间的长链接请求
        else if( uri == "/room")
        {
            return wsclose_game_room(conn);
        }
    }
    //------------------------------------------------------------------------------
    // 游戏大厅信息处理
    void wsmessage_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        // 1. 获取客户端session，识别客户端信息
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
            { return ; }
        // 2. 获取请求信息
        string req_body = msg->get_payload();
        Json::Value req_json;
        if(json_util::unserialize(req_body, req_json) == false)
        {
            return ws_resp(conn, "unknow", false, "请求信息解析失败！");
        }

        // 3. 对于请求进行处理

        // 3.1 开始对战匹配
        if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            // 将玩家添加到匹配队列
            if(_mm.add(ssp->get_user()) == false)
            { return ws_resp(conn, "match_start", false, "匹配时获取用户信息失败！"); }
            return ws_resp(conn, "match_start", true, "成功加⼊匹配队列！");
        }
        // 3.2 取消对战匹配
        else if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            if(_mm.del(ssp->get_user()) == false)
            { return ws_resp(conn, "match_stop", false, "取消时获取用户信息失败！"); }
            return ws_resp(conn, "match_stop", true, "停止匹配！");
        }
        //请求类型为空
        return ws_resp(conn, "unknow", false, "未知请求类型！");
    }
    // 游戏房间信息处理
    void wsmessage_game_room(wsserver_t::connection_ptr& conn, wsserver_t::message_ptr msg)
    {
        // 1. 获取客户端session，识别客户端信息
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
            { return ; }
        // 2. 获取请求信息，对请求信息反序列化
        string req_body = msg->get_payload();
        Json::Value req_json;
        if(json_util::unserialize(req_body, req_json) == false)
        {
            return ws_resp(conn, "unknow", false, "请求信息解析失败！");
        }
        // 获取房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if(rp.get() == nullptr)
        {
            return ws_resp(conn, "unknow", false, "获取房间信息失败！");
        }
        // 通过房间模块进行消息的处理
        return rp->handler_message(req_json);

    }
    // websocket长连接信息处理函数
    void wsmessage_callback(websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 游戏大厅信息处理
        if(uri == "/hall")
        {
            return wsmessage_game_hall(conn, msg);
        }
        // 游戏房间信息处理
        else if( uri == "/room")
        {
            return wsmessage_game_room(conn, msg);
        }
    }

private:
    string _web_root;   //静态资源根目录  ./wwwroot/
    wsserver_t _wssvr;
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _sm;
    matcher _mm;
};

#endif